import random  # used for generating large random lists
import string  # used for string sorting tests
import sys  # used for edge numeric values

# imports
import pytest  # used for our unit tests
from code_to_optimize.bubble_sort import sorter

# unit tests

# -----------------
# BASIC TEST CASES
# -----------------

def test_sorter_empty_list():
    # Test sorting an empty list
    arr = []
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 4.21μs -> 2.96μs (42.3% faster)

def test_sorter_single_element():
    # Test sorting a list with one element
    arr = [42]
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 3.88μs -> 2.96μs (31.0% faster)

def test_sorter_sorted_list():
    # Test sorting an already sorted list
    arr = [1, 2, 3, 4, 5]
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 4.54μs -> 3.04μs (49.4% faster)

def test_sorter_reverse_sorted_list():
    # Test sorting a reverse-sorted list
    arr = [5, 4, 3, 2, 1]
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 4.96μs -> 2.96μs (67.6% faster)

def test_sorter_unsorted_list():
    # Test sorting a random unsorted list
    arr = [3, 1, 4, 5, 2]
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 4.46μs -> 3.00μs (48.6% faster)

def test_sorter_with_duplicates():
    # Test sorting a list with duplicate values
    arr = [3, 1, 2, 3, 1]
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 4.12μs -> 2.96μs (39.5% faster)

def test_sorter_negative_numbers():
    # Test sorting a list with negative numbers
    arr = [-1, -3, 2, 0, -2]
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 4.50μs -> 3.04μs (47.9% faster)

def test_sorter_all_equal():
    # Test sorting a list where all elements are equal
    arr = [7, 7, 7, 7]
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 3.79μs -> 2.92μs (30.0% faster)

def test_sorter_strings():
    # Test sorting a list of strings
    arr = ["banana", "apple", "cherry"]
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 4.00μs -> 3.17μs (26.3% faster)

def test_sorter_floats():
    # Test sorting a list of floats
    arr = [3.1, 2.4, 5.6, 1.2]
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 5.83μs -> 3.62μs (60.9% faster)

def test_sorter_mixed_int_float():
    # Test sorting a list of ints and floats
    arr = [3, 2.1, 5, 1.5]
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 5.00μs -> 3.50μs (42.9% faster)

# -----------------
# EDGE TEST CASES
# -----------------

def test_sorter_large_negative_and_positive():
    # Test sorting a list with very large and very small numbers
    arr = [sys.maxsize, -sys.maxsize-1, 0, 999999, -999999]
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 6.38μs -> 3.42μs (86.6% faster)

def test_sorter_min_max_float():
    # Test sorting with extreme float values
    arr = [float('inf'), float('-inf'), 0.0, 1.0, -1.0]
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 6.08μs -> 3.29μs (84.8% faster)

def test_sorter_nan_behavior():
    # Test sorting with NaN present (should always be at the end in Python's default sort)
    arr = [3, float('nan'), 2]
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 4.71μs -> 3.17μs (48.7% faster)

def test_sorter_unicode_strings():
    # Test sorting with unicode strings
    arr = ["éclair", "apple", "Éclair", "banana"]
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 5.46μs -> 3.75μs (45.5% faster)

def test_sorter_empty_strings():
    # Test sorting with empty strings
    arr = ["", "banana", "", "apple"]
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 4.33μs -> 3.17μs (36.8% faster)

def test_sorter_large_identical_elements():
    # Test sorting a large list of identical elements
    arr = [5] * 1000
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 18.1ms -> 26.5μs (68156% faster)

def test_sorter_heterogeneous_types():
    # Test sorting a list with incomparable types should raise TypeError
    arr = [1, "two", 3]
    with pytest.raises(TypeError):
        sorter(arr.copy()) # 2.75μs -> 2.00μs (37.5% faster)

def test_sorter_mutation():
    # Test that the sorter function returns the same list object (in-place sort)
    arr = [3, 2, 1]
    codeflash_output = sorter(arr); result = codeflash_output # 4.29μs -> 2.92μs (47.2% faster)

# -----------------
# LARGE SCALE TEST CASES
# -----------------

def test_sorter_large_random_integers():
    # Test sorting a large list of random integers
    arr = random.sample(range(-100000, -99000), 1000)
    expected = sorted(arr)
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 28.1ms -> 61.7μs (45466% faster)

def test_sorter_large_random_floats():
    # Test sorting a large list of random floats
    arr = [random.uniform(-1e6, 1e6) for _ in range(1000)]
    expected = sorted(arr)
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 26.6ms -> 268μs (9803% faster)

def test_sorter_large_random_strings():
    # Test sorting a large list of random strings
    arr = [
        ''.join(random.choices(string.ascii_letters + string.digits, k=10))
        for _ in range(1000)
    ]
    expected = sorted(arr)
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 29.7ms -> 95.2μs (31127% faster)

def test_sorter_large_sorted_list():
    # Test sorting a large already sorted list (best case for some algorithms)
    arr = list(range(1000))
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 18.6ms -> 28.3μs (65724% faster)

def test_sorter_large_reverse_sorted_list():
    # Test sorting a large reverse sorted list (worst case for bubble sort)
    arr = list(range(999, -1, -1))
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 30.6ms -> 28.3μs (107742% faster)

def test_sorter_large_duplicates():
    # Test sorting a large list with many duplicates
    arr = [random.choice([1, 2, 3, 4, 5]) for _ in range(1000)]
    expected = sorted(arr)
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 25.0ms -> 47.8μs (52125% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

import random  # used for generating large random lists
import sys  # used for maxsize/minsize edge cases

# imports
import pytest  # used for our unit tests
from code_to_optimize.bubble_sort import sorter

# unit tests

# ------------------ BASIC TEST CASES ------------------

def test_sorter_empty_list():
    # Test sorting an empty list
    arr = []
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 3.88μs -> 2.88μs (34.8% faster)

def test_sorter_single_element():
    # Test sorting a single-element list
    arr = [42]
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 4.00μs -> 2.92μs (37.1% faster)

def test_sorter_sorted_list():
    # Test sorting an already sorted list
    arr = [1, 2, 3, 4, 5]
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 4.46μs -> 2.96μs (50.7% faster)

def test_sorter_reverse_sorted():
    # Test sorting a reverse-sorted list
    arr = [5, 4, 3, 2, 1]
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 5.00μs -> 2.96μs (69.0% faster)

def test_sorter_duplicates():
    # Test sorting a list with duplicate elements
    arr = [3, 1, 2, 3, 1]
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 4.75μs -> 2.96μs (60.6% faster)

def test_sorter_negative_numbers():
    # Test sorting a list with negative numbers
    arr = [-2, -5, -3, 0, 2, 1]
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 5.12μs -> 3.08μs (66.2% faster)

def test_sorter_mixed_signs():
    # Test sorting a list with both positive and negative numbers
    arr = [3, -1, 0, 2, -5]
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 4.96μs -> 3.08μs (60.8% faster)

def test_sorter_all_equal():
    # Test sorting a list where all elements are the same
    arr = [7, 7, 7, 7]
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 4.42μs -> 2.92μs (51.5% faster)

def test_sorter_floats():
    # Test sorting a list of floats
    arr = [2.2, 1.1, 3.3, -1.1, 0.0]
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 6.33μs -> 3.75μs (68.9% faster)

def test_sorter_mixed_int_float():
    # Test sorting a list with both ints and floats
    arr = [1, 2.5, 0, -3.2, 2]
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 6.38μs -> 3.62μs (75.9% faster)

# ------------------ EDGE TEST CASES ------------------

def test_sorter_large_numbers():
    # Test sorting with very large and very small numbers
    arr = [sys.maxsize, -sys.maxsize-1, 0, 999999999, -999999999]
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 6.04μs -> 3.46μs (74.7% faster)

def test_sorter_min_max_float():
    # Test sorting with extreme float values
    arr = [float('inf'), float('-inf'), 0.0, 1.0, -1.0]
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 5.79μs -> 3.33μs (73.7% faster)

def test_sorter_nan_values():
    # Test sorting with NaN values (NaNs should always be at the end in Python's sort)
    arr = [3, float('nan'), 2, 1]
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 5.04μs -> 3.25μs (55.1% faster)

def test_sorter_already_sorted_with_duplicates():
    # Test already sorted list with duplicates
    arr = [1, 2, 2, 3, 4, 4, 5]
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 5.25μs -> 2.96μs (77.5% faster)


def test_sorter_mixed_types_should_fail():
    # Test that sorting a list with mixed types (e.g., int and str) raises a TypeError
    arr = [1, "a", 3]
    with pytest.raises(TypeError):
        sorter(arr.copy()) # 2.88μs -> 2.00μs (43.8% faster)

def test_sorter_none_value_should_fail():
    # Test that sorting a list with None raises a TypeError
    arr = [1, None, 2]
    with pytest.raises(TypeError):
        sorter(arr.copy()) # 2.50μs -> 1.83μs (36.4% faster)

def test_sorter_single_nan():
    # Sorting a list with a single NaN should return the same list
    arr = [float('nan')]
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 4.21μs -> 3.04μs (38.3% faster)

def test_sorter_all_nan():
    # Sorting a list of all NaNs should return the same list
    arr = [float('nan')] * 5
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 5.08μs -> 3.29μs (54.4% faster)

# ------------------ LARGE SCALE TEST CASES ------------------

def test_sorter_large_random_list():
    # Test sorting a large random list (size 1000)
    arr = random.sample(range(-10000, -9000), 1000)
    expected = sorted(arr)
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 28.2ms -> 59.8μs (46980% faster)

def test_sorter_large_duplicates():
    # Test sorting a large list with many duplicates
    arr = [random.choice([1, 2, 3, 4, 5]) for _ in range(1000)]
    expected = sorted(arr)
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 24.9ms -> 47.9μs (51776% faster)

def test_sorter_large_already_sorted():
    # Test sorting a large already sorted list
    arr = list(range(1000))
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 18.6ms -> 28.2μs (65820% faster)

def test_sorter_large_reverse_sorted():
    # Test sorting a large reverse-sorted list
    arr = list(range(999, -1, -1))
    expected = list(range(1000))
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 30.6ms -> 28.5μs (107175% faster)

def test_sorter_large_negative_numbers():
    # Test sorting a large list of negative numbers
    arr = [random.randint(-10000, -1) for _ in range(1000)]
    expected = sorted(arr)
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 27.5ms -> 60.6μs (45356% faster)

def test_sorter_large_floats():
    # Test sorting a large list of floats
    arr = [random.uniform(-10000, 10000) for _ in range(1000)]
    expected = sorted(arr)
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 27.4ms -> 266μs (10193% faster)

# ------------------ MUTATION TESTS (FUNCTIONALITY ENFORCEMENT) ------------------

def test_sorter_is_stable():
    # Bubble sort is stable: equal elements retain their relative order
    class StableObj:
        def __init__(self, value, tag):
            self.value = value
            self.tag = tag
        def __lt__(self, other):
            return self.value < other.value
        def __gt__(self, other):
            return self.value > other.value
        def __eq__(self, other):
            return self.value == other.value and self.tag == other.tag
        def __repr__(self):
            return f"({self.value}, {self.tag})"
    arr = [StableObj(1, 'a'), StableObj(2, 'b'), StableObj(1, 'c'), StableObj(2, 'd')]
    # Sorting should keep ('a', 'c') before ('b', 'd')
    codeflash_output = sorter(arr.copy()); sorted_arr = codeflash_output # 6.83μs -> 4.50μs (51.8% faster)

def test_sorter_original_list_mutated():
    # Ensure the original list passed to sorter is mutated (since the function sorts in-place)
    arr = [2, 1]
    sorter(arr) # 4.17μs -> 2.96μs (40.9% faster)

def test_sorter_return_value_is_same_list():
    # Ensure the returned list is the same object as the input (in-place sort)
    arr = [3, 2, 1]
    codeflash_output = sorter(arr); result = codeflash_output # 4.62μs -> 2.92μs (58.6% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.